ReactJS Ultra For Beginners

⚡ Async React


What is Async React?

  • Modern React patterns for handling asynchronous operations
  • Includes Suspense, Server Components, and concurrent features
  • Improves user experience with better loading states
  • Enables more efficient data fetching and rendering

📝 Suspense

Basic Suspense Usage:

import { Suspense } from "react"; function App() { return ( <div> <Suspense fallback={<div>Loading...</div>}> <UserProfile /> </Suspense> </div> ); } function UserProfile() { // This component might suspend during data fetching const user = useUser(); // Custom hook that can suspend return <div>Welcome, {user.name}!</div>; }

Multiple Suspense Boundaries:

function Dashboard() { return ( <div> <Header /> <Suspense fallback={<UserSkeleton />}> <UserInfo /> </Suspense> <Suspense fallback={<PostsSkeleton />}> <RecentPosts /> </Suspense> </div> ); }

🔑 Server Components

Server Component Example:

// This runs on the server async function UserList() { const users = await fetchUsers(); // Server-side data fetching return ( <ul> {users.map((user) => ( <li key={user.id}>{user.name}</li> ))} </ul> ); } // Client Component (runs in browser) ("use client"); function UserActions({ userId }) { const [liked, setLiked] = useState(false); return ( <button onClick={() => setLiked(!liked)}>{liked ? "❤️" : "🤍"}</button> ); }

Mixing Server and Client Components:

// Server Component async function UserProfile({ userId }) { const user = await fetchUser(userId); return ( <div> <h1>{user.name}</h1> <p>{user.email}</p> {/* Client Component for interactivity */} <UserActions userId={userId} /> </div> ); } // Client Component ("use client"); function UserActions({ userId }) { const [isEditing, setIsEditing] = useState(false); return ( <div> <button onClick={() => setIsEditing(true)}>Edit</button> {isEditing && <EditForm userId={userId} />} </div> ); }

🎯 Concurrent Features

useTransition Hook:

import { useTransition, useState } from "react"; function SearchResults() { const [query, setQuery] = useState(""); const [results, setResults] = useState([]); const [isPending, startTransition] = useTransition(); const handleSearch = (newQuery) => { setQuery(newQuery); // Update immediately startTransition(() => { // This update is marked as non-urgent setResults(searchAPI(newQuery)); }); }; return ( <div> <input value={query} onChange={(e) => handleSearch(e.target.value)} placeholder="Search..." /> {isPending && <div>Searching...</div>} <ResultsList results={results} /> </div> ); }

useDeferredValue Hook:

import { useDeferredValue, useState, useMemo } from "react"; function ExpensiveList({ query }) { const deferredQuery = useDeferredValue(query); const filteredList = useMemo(() => { return expensiveFilterOperation(deferredQuery); }, [deferredQuery]); return ( <ul> {filteredList.map((item) => ( <li key={item.id}>{item.name}</li> ))} </ul> ); } function SearchApp() { const [query, setQuery] = useState(""); return ( <div> <input value={query} onChange={(e) => setQuery(e.target.value)} placeholder="Search..." /> <ExpensiveList query={query} /> </div> ); }

🔧 Data Fetching Patterns

Suspense-enabled Data Fetching:

// Custom hook that supports Suspense function useUser(userId) { const userPromise = useMemo(() => { return fetchUser(userId); }, [userId]); const user = use(userPromise); // React 18+ use hook return user; } // Component that can suspend function UserProfile({ userId }) { const user = useUser(userId); // This can suspend return ( <div> <h1>{user.name}</h1> <p>{user.email}</p> </div> ); } // Usage with Suspense function App() { return ( <Suspense fallback={<UserSkeleton />}> <UserProfile userId={123} /> </Suspense> ); }

Error Boundaries with Suspense:

class ErrorBoundary extends React.Component { constructor(props) { super(props); this.state = { hasError: false }; } static getDerivedStateFromError(error) { return { hasError: true }; } render() { if (this.state.hasError) { return <h1>Something went wrong.</h1>; } return this.props.children; } } function App() { return ( <ErrorBoundary> <Suspense fallback={<Loading />}> <UserProfile /> </Suspense> </ErrorBoundary> ); }

🎯 Lazy Loading

Component Lazy Loading:

import { lazy, Suspense } from "react"; const UserProfile = lazy(() => import("./UserProfile")); const Settings = lazy(() => import("./Settings")); function App() { const [currentPage, setCurrentPage] = useState("profile"); return ( <div> <nav> <button onClick={() => setCurrentPage("profile")}>Profile</button> <button onClick={() => setCurrentPage("settings")}>Settings</button> </nav> <Suspense fallback={<div>Loading page...</div>}> {currentPage === "profile" && <UserProfile />} {currentPage === "settings" && <Settings />} </Suspense> </div> ); }

Data Lazy Loading:

function InfiniteScroll() { const [items, setItems] = useState([]); const [page, setPage] = useState(1); const [hasMore, setHasMore] = useState(true); const loadMore = async () => { const newItems = await fetchItems(page); setItems((prev) => [...prev, ...newItems]); setPage((prev) => prev + 1); setHasMore(newItems.length > 0); }; return ( <div> {items.map((item) => ( <Item key={item.id} item={item} /> ))} {hasMore && ( <Suspense fallback={<LoadingMore />}> <LoadMoreButton onLoad={loadMore} /> </Suspense> )} </div> ); }

🔄 Streaming SSR

Streaming Server-Side Rendering:

// Server Component with streaming async function BlogPost({ postId }) { const post = await fetchPost(postId); return ( <article> <h1>{post.title}</h1> <Suspense fallback={<CommentsSkeleton />}> <Comments postId={postId} /> </Suspense> </article> ); } // Comments component that streams in async function Comments({ postId }) { const comments = await fetchComments(postId); return ( <div> {comments.map((comment) => ( <Comment key={comment.id} comment={comment} /> ))} </div> ); }

⚠️ Best Practices

  1. Use Suspense boundaries strategically - wrap components that can suspend
  2. Provide meaningful fallbacks - show loading states that match the content
  3. Handle errors gracefully - use Error Boundaries with Suspense
  4. Optimize for user experience - use concurrent features for non-urgent updates
  5. Lazy load appropriately - split code and data loading for better performance
  6. Test Suspense behavior - ensure your app handles loading states correctly

🔧 Migration Guide

From useEffect to Suspense:

// Old pattern function UserProfile({ userId }) { const [user, setUser] = useState(null); const [loading, setLoading] = useState(true); useEffect(() => { fetchUser(userId) .then(setUser) .finally(() => setLoading(false)); }, [userId]); if (loading) return <div>Loading...</div>; if (!user) return <div>User not found</div>; return <div>{user.name}</div>; } // New pattern with Suspense function UserProfile({ userId }) { const user = useUser(userId); // Can suspend return <div>{user.name}</div>; } // Wrap with Suspense <Suspense fallback={<div>Loading...</div>}> <UserProfile userId={123} /> </Suspense>;